Macwelt 1/Macwelt DVD 1.toast/Software für Mac-OS X/Entwickler-Tools/netbeans/modules/ext/djava.jar/koala/dynamicjava/interpreter/TreeInterpreter.class

Java Class File | 2000-03-14 | 12.5 KB | 491 lines

package koala.dynamicjava.interpreter;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import koala.dynamicjava.interpreter.context.Context;
import koala.dynamicjava.interpreter.context.GlobalContext;
import koala.dynamicjava.interpreter.context.MethodContext;
import koala.dynamicjava.interpreter.context.StaticContext;
import koala.dynamicjava.interpreter.error.ExecutionError;
import koala.dynamicjava.interpreter.throwable.ReturnException;
import koala.dynamicjava.parser.wrapper.ParseError;
import koala.dynamicjava.parser.wrapper.ParserFactory;
import koala.dynamicjava.parser.wrapper.SourceCodeParser;
import koala.dynamicjava.tree.FormalParameter;
import koala.dynamicjava.tree.MethodDeclaration;
import koala.dynamicjava.tree.Node;
import koala.dynamicjava.util.ImportationManager;
import koala.dynamicjava.util.LibraryFinder;

public class TreeInterpreter implements Interpreter {
   protected static Map methods = new HashMap();
   protected static Map constructorParameters = new HashMap();
   protected static int nClass;
   protected ParserFactory parserFactory;
   protected LibraryFinder libraryFinder = new LibraryFinder();
   protected TreeClassLoader classLoader;
   List localMethods = new LinkedList();
   List localConstructorParameters = new LinkedList();
   protected Context nameVisitorContext;
   protected Context checkVisitorContext;
   protected Context evalVisitorContext;
   // $FF: synthetic field
   private static Class class$Lkoala$dynamicjava$interpreter$error$CatchedExceptionError;

   public Object interpret(Reader var1, String var2) throws InterpreterException {
      try {
         SourceCodeParser var3 = this.parserFactory.createParser(var1, var2);
         List var4 = var3.parseStream();
         ListIterator var5 = var4.listIterator();

         Object var6;
         Node var7;
         EvaluationVisitor var13;
         for(var6 = null; var5.hasNext(); var6 = var7.acceptVisitor(var13)) {
            var7 = (Node)var5.next();
            NameVisitor var8 = new NameVisitor(this.nameVisitorContext);
            Object var9 = var7.acceptVisitor(var8);
            if (var9 != null) {
               var7 = (Node)var9;
            }

            TypeChecker var12 = new TypeChecker(this.checkVisitorContext);
            var7.acceptVisitor(var12);
            this.evalVisitorContext.defineVariables(this.checkVisitorContext.getCurrentScopeVariables());
            var13 = new EvaluationVisitor(this.evalVisitorContext);
         }

         return var6;
      } catch (ExecutionError var10) {
         throw new InterpreterException(var10);
      } catch (ParseError var11) {
         throw new InterpreterException(var11);
      }
   }

   public Object interpret(InputStream var1, String var2) throws InterpreterException {
      return this.interpret((Reader)(new InputStreamReader(var1)), var2);
   }

   public Object interpret(String var1) throws InterpreterException, IOException {
      return this.interpret((Reader)(new FileReader(var1)), var1);
   }

   public void defineVariable(String var1, Object var2) {
      Class var3 = var2 == null ? null : var2.getClass();
      this.nameVisitorContext.define(var1, var3);
      this.checkVisitorContext.define(var1, var3);
      this.evalVisitorContext.define(var1, var2);
   }

   public void setVariable(String var1, Object var2) {
      Class var3 = (Class)this.checkVisitorContext.get(var1);
      if (InterpreterUtilities.isValidAssignment(var3, var2)) {
         this.evalVisitorContext.set(var1, var2);
      } else {
         throw new IllegalStateException(var1);
      }
   }

   public Object getVariable(String var1) {
      return this.evalVisitorContext.get(var1);
   }

   public Class getVariableClass(String var1) {
      return (Class)this.checkVisitorContext.get(var1);
   }

   public Set getVariableNames() {
      return this.evalVisitorContext.getCurrentScopeVariableNames();
   }

   public Set getClassNames() {
      return this.classLoader.getClassNames();
   }

   public void addClassPath(String var1) {
      try {
         this.classLoader.addURL((new File(var1)).toURL());
      } catch (MalformedURLException var3) {
      }

   }

   public void addClassURL(URL var1) {
      this.classLoader.addURL(var1);
   }

   public void addLibraryPath(String var1) {
      this.libraryFinder.addPath(var1);
   }

   public void addLibrarySuffix(String var1) {
      this.libraryFinder.addSuffix(var1);
   }

   public Class loadClass(String var1) throws ClassNotFoundException {
      return (new TreeCompiler(this)).compile(var1);
   }

   public Class defineClass(String var1, byte[] var2) {
      return this.classLoader.defineClass(var1, var2);
   }

   public ClassLoader getClassLoader() {
      return this.classLoader;
   }

   public LibraryFinder getLibraryFinder() {
      return this.libraryFinder;
   }

   public ParserFactory getParserFactory() {
      return this.parserFactory;
   }

   public Class getExceptionClass() {
      return class$Lkoala$dynamicjava$interpreter$error$CatchedExceptionError != null ? class$Lkoala$dynamicjava$interpreter$error$CatchedExceptionError : (class$Lkoala$dynamicjava$interpreter$error$CatchedExceptionError = class$("koala.dynamicjava.interpreter.error.CatchedExceptionError"));
   }

   public void registerMethod(String var1, MethodDeclaration var2, ImportationManager var3) {
      this.localMethods.add(var1);
      Map var10000 = methods;
      MethodDescriptor var10002 = new MethodDescriptor;
      if (this == null) {
         throw null;
      } else {
         var10002.<init>(this, var2, var3);
         var10000.put(var1, var10002);
      }
   }

   public static Object invokeMethod(String var0, Object var1, Object[] var2) {
      MethodDescriptor var3 = (MethodDescriptor)methods.get(var0);
      Class var4 = null;

      try {
         var4 = Class.forName(var0.substring(0, var0.lastIndexOf(35)), true, var3.interpreter.getClassLoader());
      } catch (ClassNotFoundException var6) {
         var6.printStackTrace();
      }

      return var3.interpreter.interpretMethod(var4, var3, var1, var2);
   }

   protected Object interpretMethod(Class var1, MethodDescriptor var2, Object var3, Object[] var4) {
      MethodDeclaration var5 = var2.method;
      List var6 = var5.getParameters();
      List var7 = var5.getBody().getStatements();
      String var8 = var5.getName();
      Object var9 = null;
      if (Modifier.isStatic(var2.method.getAccessFlags())) {
         if (var2.variables == null) {
            var2.importationManager.setClassLoader(this.classLoader);
            StaticContext var10 = new StaticContext(this, var1, var2.importationManager);
            var10.setAdditionalClassLoaderContainer(this.classLoader);
            NameVisitor var11 = new NameVisitor(var10);
            ListIterator var12 = var6.listIterator();

            while(var12.hasNext()) {
               ((Node)var12.next()).acceptVisitor(var11);
            }

            var12 = var7.listIterator();

            while(var12.hasNext()) {
               Object var13 = ((Node)var12.next()).acceptVisitor(var11);
               if (var13 != null) {
                  var12.set(var13);
               }
            }

            var10 = new StaticContext(this, var1, var2.importationManager);
            var10.setAdditionalClassLoaderContainer(this.classLoader);
            TypeChecker var30 = new TypeChecker(var10);
            var12 = var6.listIterator();

            while(var12.hasNext()) {
               ((Node)var12.next()).acceptVisitor(var30);
            }

            var12 = var7.listIterator();

            while(var12.hasNext()) {
               ((Node)var12.next()).acceptVisitor(var30);
            }

            var2.variables = var10.getCurrentScopeVariables();
            if (!var8.equals("<clinit>") && !var8.equals("<init>")) {
               try {
                  var2.contextField = var1.getField("local$Variables$Reference$0");
               } catch (NoSuchFieldException var20) {
               }
            }
         }

         var9 = new StaticContext(this, var1, var2.variables);
      } else {
         if (var2.variables == null) {
            var2.importationManager.setClassLoader(this.classLoader);
            MethodContext var25 = new MethodContext(this, var1, var1, var2.importationManager);
            var25.setAdditionalClassLoaderContainer(this.classLoader);
            NameVisitor var31 = new NameVisitor(var25);
            MethodContext var37 = new MethodContext(this, var1, var1, var2.importationManager);
            var37.setAdditionalClassLoaderContainer(this.classLoader);
            NameVisitor var41 = new NameVisitor(var37);
            Object[][] var14 = null;

            try {
               Field var15 = var1.getField("local$Variables$Class$0");
               var14 = var15.get(var3);

               for(int var16 = 0; var16 < var14.length; ++var16) {
                  Object[] var17 = var14[var16];
                  if (!((String)var17[0]).equals("this")) {
                     var25.defineConstant((String)var17[0], var17[1]);
                  }
               }
            } catch (Exception var22) {
            }

            ListIterator var44 = var6.listIterator();

            while(var44.hasNext()) {
               ((Node)var44.next()).acceptVisitor(var31);
            }

            var44 = var7.listIterator();

            while(var44.hasNext()) {
               Node var48 = (Node)var44.next();
               Object var51 = null;
               if (var48.hasProperty("instanceInitializer")) {
                  var51 = var48.acceptVisitor(var41);
               } else {
                  var51 = var48.acceptVisitor(var31);
               }

               if (var51 != null) {
                  var44.set(var51);
               }
            }

            var25 = new MethodContext(this, var1, var1, var2.importationManager);
            var25.setAdditionalClassLoaderContainer(this.classLoader);
            TypeChecker var32 = new TypeChecker(var25);
            var37 = new MethodContext(this, var1, var1, var2.importationManager);
            var37.setAdditionalClassLoaderContainer(this.classLoader);
            TypeChecker var42 = new TypeChecker(var37);
            if (var14 != null) {
               for(int var49 = 0; var49 < var14.length; ++var49) {
                  Object[] var53 = var14[var49];
                  if (!((String)var53[0]).equals("this")) {
                     var25.defineConstant((String)var53[0], var53[1]);
                  }
               }
            }

            var44 = var6.listIterator();

            while(var44.hasNext()) {
               ((Node)var44.next()).acceptVisitor(var32);
            }

            var44 = var7.listIterator();

            while(var44.hasNext()) {
               Node var50 = (Node)var44.next();
               if (var50.hasProperty("instanceInitializer")) {
                  var50.acceptVisitor(var42);
               } else {
                  var50.acceptVisitor(var32);
               }
            }

            var2.variables = var25.getCurrentScopeVariables();
            if (!var8.equals("<clinit>") && !var8.equals("<init>")) {
               try {
                  var2.contextField = var1.getField("local$Variables$Reference$0");
               } catch (NoSuchFieldException var19) {
               }
            }
         }

         var9 = new MethodContext(this, var1, var3, var2.variables);
      }

      ((Context)var9).setAdditionalClassLoaderContainer(this.classLoader);
      Iterator var27 = var6.iterator();
      int var33 = 0;

      while(var27.hasNext()) {
         ((Context)var9).set(((FormalParameter)var27.next()).getName(), var4[var33++]);
      }

      if (var2.contextField != null) {
         Map var39 = null;

         try {
            var39 = (Map)var2.contextField.get(var3);
         } catch (IllegalAccessException var18) {
         }

         if (var39 != null) {
            for(String var43 : var39.keySet()) {
               if (!var43.equals("this")) {
                  ((Context)var9).setConstant(var43, var39.get(var43));
               }
            }
         }
      }

      EvaluationVisitor var40 = new EvaluationVisitor((Context)var9);
      var27 = var7.iterator();

      try {
         while(var27.hasNext()) {
            ((Node)var27.next()).acceptVisitor(var40);
         }

         return null;
      } catch (ReturnException var21) {
         return var21.getValue();
      }
   }

   public void registerConstructorArguments(String var1, List var2, List var3, ImportationManager var4) {
      this.localConstructorParameters.add(var1);
      Map var10000 = constructorParameters;
      ConstructorParametersDescriptor var10002 = new ConstructorParametersDescriptor;
      if (this == null) {
         throw null;
      } else {
         var10002.<init>(this, var2, var3, var4);
         var10000.put(var1, var10002);
      }
   }

   public static Object[] interpretArguments(String var0, Object[] var1) {
      ConstructorParametersDescriptor var2 = (ConstructorParametersDescriptor)constructorParameters.get(var0);
      Class var3 = null;

      try {
         var3 = Class.forName(var0.substring(0, var0.lastIndexOf(35)), true, var2.interpreter.getClassLoader());
      } catch (ClassNotFoundException var5) {
         var5.printStackTrace();
      }

      return var2.interpreter.interpretArguments(var3, var2, var1);
   }

   protected Object[] interpretArguments(Class var1, ConstructorParametersDescriptor var2, Object[] var3) {
      if (var2.variables == null) {
         var2.importationManager.setClassLoader(this.classLoader);
         StaticContext var4 = new StaticContext(this, var1, var2.importationManager);
         var4.setAdditionalClassLoaderContainer(this.classLoader);
         NameVisitor var5 = new NameVisitor(var4);
         TypeChecker var6 = new TypeChecker(var4);
         if (var2.parameters != null) {
            ListIterator var7 = var2.parameters.listIterator();

            while(var7.hasNext()) {
               ((Node)var7.next()).acceptVisitor(var6);
            }
         }

         if (var2.arguments != null) {
            ListIterator var15 = var2.arguments.listIterator();

            while(var15.hasNext()) {
               Node var8 = (Node)var15.next();
               Object var9 = var8.acceptVisitor(var5);
               if (var9 != null) {
                  var15.set(var9);
               }
            }

            var15 = var2.arguments.listIterator();

            while(var15.hasNext()) {
               ((Node)var15.next()).acceptVisitor(var6);
            }
         }

         var2.variables = var4.getCurrentScopeVariables();
      }

      StaticContext var10 = new StaticContext(this, var1, var2.variables);
      var10.setAdditionalClassLoaderContainer(this.classLoader);
      if (var2.parameters != null) {
         Iterator var11 = var2.parameters.iterator();
         int var13 = 0;

         while(var11.hasNext()) {
            var10.set(((FormalParameter)var11.next()).getName(), var3[var13++]);
         }
      }

      Object[] var12 = new Object[0];
      if (var2.arguments != null) {
         EvaluationVisitor var14 = new EvaluationVisitor(var10);
         ListIterator var17 = var2.arguments.listIterator();
         var12 = new Object[var2.arguments.size()];

         for(int var18 = 0; var17.hasNext(); var12[var18++] = ((Node)var17.next()).acceptVisitor(var14)) {
         }
      }

      return var12;
   }

   protected void finalize() throws Throwable {
      Iterator var1 = this.localMethods.iterator();

      while(var1.hasNext()) {
         methods.remove(var1.next());
      }

      var1 = this.localConstructorParameters.iterator();

      while(var1.hasNext()) {
         constructorParameters.remove(var1.next());
      }

   }

   // $FF: synthetic method
   static Class class$(String var0) {
      try {
         return Class.forName(var0);
      } catch (ClassNotFoundException var2) {
         throw new NoClassDefFoundError(((Throwable)var2).getMessage());
      }
   }

   public TreeInterpreter(ParserFactory var1) {
      this.parserFactory = var1;
      this.classLoader = new TreeClassLoader(this);
      this.nameVisitorContext = new GlobalContext(this);
      this.nameVisitorContext.setAdditionalClassLoaderContainer(this.classLoader);
      this.checkVisitorContext = new GlobalContext(this);
      this.checkVisitorContext.setAdditionalClassLoaderContainer(this.classLoader);
      this.evalVisitorContext = new GlobalContext(this);
      this.evalVisitorContext.setAdditionalClassLoaderContainer(this.classLoader);
   }
}